Natural Language is a Programming Language: Applying Natural Language Processing to Software Development

A powerful, but limited, way to view software is as source code alone. Treating a program as a sequence of instructions enables it to be formalized and makes it amenable to mathematical techniques such as abstract interpretation and model checking. A program consists of much more than a sequence of instructions. Developers make use of test cases, documentation, variable names, program structure, the version control repository, and more. I argue that it is time to take the blinders off of software analysis tools: tools should use all these artifacts to deduce more powerful and useful information about the program. Researchers are beginning to make progress towards this vision. This paper gives, as examples, four results that find bugs and generate code by applying natural language processing techniques to software artifacts. The four techniques use as input error messages, variable names, procedure documentation, and user questions. They use four different NLP techniques: document similarity, word semantics, parse trees, and neural networks. The initial results suggest that this is a promising avenue for future work

Quantitative Information-Flow Tracking for C and Related Languages

We present a new approach for tracking programs' use of data througharbitrary calculations, to determine how much information about secretinputs is revealed by public outputs. Using a fine-grained dynamicbit-tracking analysis, the technique measures the information revealedduring a particular execution. The technique accounts for indirectflows, e.g. via branches and pointer operations. Two kinds ofuntrusted annotation improve the precision of the analysis. Animplementation of the technique based on dynamic binary translation isdemonstrated on real C, C++, and Objective C programs of up to half amillion lines of code. In case studies, the tool checked multiplesecurity policies, including one that was violated by a previouslyunknown bug

36 degree step size of proton-driven c-ring rotation in FoF1-ATP synthase

Synthesis of the biological "energy currency molecule" adenosine triphosphate ATP is accomplished by FoF1-ATP synthase. In the plasma membrane of Escherichia coli, proton-driven rotation of a ring of 10 c subunits in the Fo motor powers catalysis in the F1 motor. While F1 uses 120 degree stepping, Fo models predict a step-by-step rotation of c subunits 36 degree at a time, which is here demonstrated by single-molecule fluorescence resonance energy transfer.Comment: 8 pages, 1 figur

Theories in Practice: Easy-to-Write Specifications that Catch Bugs

Automated testing during development helps ensure that software works according to the test suite. Traditional test suites verify a few well-picked scenarios or example inputs. However, such example-based testing does not uncover errors in legal inputs that the test writer overlooked. We propose theory-based testing as an adjunct to example-based testing. A theory generalizes a (possibly infinite) set of example-based tests. A theory is an assertion that should be true for any data, and it can be exercised by human-chosen data or by automatic data generation. A theory is expressed in an ordinary programming language, it is easy for developers to use (often even easier than example-based testing), and it serves as a lightweight form of specification. Six case studies demonstrate the utility of theories that generalize existing tests to prevent bugs, clarify intentions, and reveal design problems

ReCrash: Making Crashes Reproducible

It is difficult to fix a problem without being able to reproduce it.However, reproducing a problem is often difficult and time-consuming.This paper proposes a novel algorithm, ReCrash, that generatesmultiple unit tests that reproduce a given program crash.ReCrash dynamically tracks method calls during every execution of the target program. If the program crashes, ReCrash saves information about the relevant method calls and uses the saved information to create unit tests reproducing the crash.We present reCrashJ an implementation of ReCrash for Java. reCrashJ reproducedreal crashes from javac, SVNKit, Eclipse JDT, and BST. reCrashJ is efficient, incurring 13%-64% performance overhead. If this overhead is unacceptable, then reCrashJ has another mode that has negligible overhead until a crash occurs and 0%-1.7% overhead until a second crash, at which point the test cases are generated

How do programs become more concurrent? A story of program transformations

For several decades, programmers have relied onMooreâ s Law to improve the performance of their softwareapplications. From now on, programmers need to programthe multi-cores if they want to deliver efficient code. Inthe multi-core era, a major maintenance task will be tomake sequential programs more concurrent. What are themost common transformations to retrofit concurrency intosequential programs?We studied the source code of 5 open-source Javaprojects. We analyzed qualitatively and quantitatively thechange patterns that developers have used in order toretrofit concurrency. We found that these transformationsbelong to four categories: transformations that improve thelatency, the throughput, the scalability, or correctness of theapplications. In addition, we report on our experience ofparallelizing one of our own programs. Our findings caneducate software developers on how to parallelize sequentialprograms, and can provide hints for tool vendors aboutwhat transformations are worth automating

Refactoring Sequential Java Code for Concurrency via Concurrent Libraries

Parallelizing existing sequential programs to run efficiently on multicores is hard. The Java 5 packagejava.util.concurrent (j.u.c.) supports writing concurrent programs: much of the complexity of writing threads-safe and scalable programs is hidden in the library. To use this package, programmers still need to reengineer existing code. This is tedious because it requires changing many lines of code, is error-prone because programmers can use the wrong APIs, and is omission-prone because programmers can miss opportunities to use the enhanced APIs. This paper presents our tool, CONCURRENCER, which enables programmers to refactor sequential code into parallel code that uses j.u.c. concurrent utilities. CONCURRENCER does not require any program annotations, although the transformations are very involved: they span multiple program statements and use custom program analysis. A find-and-replace tool can not perform such transformations. Empirical evaluation shows that CONCURRENCER refactors code effectively: CONCURRENCER correctly identifies and applies transformations that some open-source developers overlooked, and the converted code exhibits good speedup

Women's quality of life is decreased by acute cystitis and antibiotic adverse effects associated with treatment

BACKGROUND: Although acute cystitis is a common infection in women, the impact of this infection and its treatment on women's quality of life (QOL) has not been previously described. Objectives: To evaluate QOL in women treated for acute cystitis, and describe the relationship between QOL, clinical outcome and adverse events of each of the interventions used in the study. METHODS: Design. Randomized, open-label, multicenter, treatment study. Setting. Two family medicine outpatient clinics in Iowa. Patients. One-hundred-fifty-seven women with clinical signs and symptoms of acute uncomplicated cystitis. Intervention. Fifty-two patients received trimethoprim/sulfamethoxazole 1 double-strength tablet twice daily for 3 days, 54 patients received ciprofloxacin 250 mg twice daily for 3 days and 51 patients received nitrofurantoin 100 mg twice daily for 7 days. Measurements. QOL was assessed at the time of enrollment and at 3, 7, 14 and 28 days after the initial visit. QOL was measured using a modified Quality of Well-Being scale, a validated, multi-attribute health scale. Clinical outcome was assessed by telephone interview on days 3, 7, 14 and 28 using a standardized questionnaire to assess resolution of symptoms, compliance with the prescribed regimen, and occurrence of adverse events. RESULTS: Patients experiencing a clinical cure had significantly better QOL at days 3 (p = 0.03), 7 (p < 0.001), and 14 (p = 0.02) compared to patients who failed treatment. While there was no difference in QOL by treatment assignment, patients experiencing an adverse event had lower QOL throughout the study period. Patients treated with ciprofloxacin appeared to experience adverse events at a higher rate (62%) compared to those treated with TMP/SMX (45%) and nitrofurantoin (49%), however the difference was not statistically significant (p = 0.2). CONCLUSION: Patients experiencing cystitis have an increase in their QOL with treatment. Those experiencing clinical cure have greater improvement in QOL compared to patients fail therapy. While QOL is improved by treatment, those reporting adverse events have lower overall QOL compared to those who do not experience adverse events. This study is important in that it suggests that both cystitis and antibiotic treatment can affect QOL in a measurable way